const BASE_URL = 'http://localhost:8080/api'; // 恢复正确的API前缀
console.log('API模块加载，BASE_URL:', BASE_URL);

/**
 * 获取帖子列表
 * @param {number} pageNum 页码
 * @param {number} pageSize 每页数量
 * @param {string} category 分类
 */
function getPostList(pageNum = 1, pageSize = 10, category = 'all') {
  console.log('API - 获取帖子列表:', { pageNum, pageSize, category });

  return new Promise((resolve, reject) => {
    const token = wx.getStorageSync('token');
    if (!token) {
      console.error('未登录状态下请求帖子列表');
      reject(new Error('请先登录'));
      return;
    }

    console.log('使用授权Token:', token);

    // 准备请求参数
    const params = { pageNum, pageSize };
    
    // 根据分类设置类型参数
    if (category && category !== 'all') {
      // 转换分类到API所需的type参数
      switch (category) {
        case 'discussion': params.type = 'discussion'; break;
        case 'question': params.type = 'question'; break;
        case 'sharing': params.type = 'sharing'; break;
        default: // all或其他情况不传type参数
      }
    }

    console.log('请求参数:', params);

    wx.request({
      url: 'http://localhost:8080/api/post/list',
      method: 'GET',
      header: {
        'Authorization': token,
        'Content-Type': 'application/json'
      },
      data: params,
      success(res) {
        console.log('帖子列表原始响应:', res);

        // 检查HTTP状态码
        if (res.statusCode !== 200) {
          console.error('HTTP错误:', res.statusCode);
          reject(new Error(`服务器返回错误: ${res.statusCode}`));
          return;
        }

        // 检查业务状态码
        if (!res.data || res.data.code !== 200) {
          const errorMsg = res.data ? res.data.message || '获取帖子失败' : '服务器响应异常';
          console.error('业务错误:', errorMsg);
          reject(new Error(errorMsg));
          return;
        }

        // 提取帖子数据
        let posts = [];
        
        if (res.data.data && res.data.data.records) {
          posts = res.data.data.records;
          console.log('成功获取帖子列表，数量:', posts.length);
          
          // 打印第一条帖子数据帮助调试
          if (posts.length > 0) {
            console.log('第一条帖子数据:', posts[0]);
            console.log('帖子字段:', Object.keys(posts[0]));
          }
          
          resolve(posts);
        } else {
          console.warn('服务器返回了空数据或格式异常');
          resolve([]);
        }
      },
      fail(err) {
        console.error('网络请求失败:', err);
        reject(new Error('网络请求失败: ' + err.errMsg));
      }
    });
  });
}

// 发布帖子
function publishPost(data, retryCount = 0) {
  console.log('API - 发布帖子，数据:', data);
  
  // 创建一个新的数据对象
  const postData = {...data};
  
  // 确保images是数组格式
  if (postData.images && !Array.isArray(postData.images)) {
    try {
      // 如果是JSON字符串，尝试解析
      if (typeof postData.images === 'string') {
        postData.images = JSON.parse(postData.images);
      } else {
        // 如果不是数组也不是字符串，转为数组
        postData.images = [postData.images];
      }
    } catch (e) {
      console.error('处理图片数据失败:', e);
      // 如果解析失败，确保是数组
      postData.images = Array.isArray(postData.images) ? postData.images : [postData.images];
    }
  }
  
  // 确保图片URLs是字符串数组
  if (postData.images && Array.isArray(postData.images)) {
    postData.images = postData.images.filter(url => url && typeof url === 'string');
  }
  
  // 保存原始图片数据到本地存储，以便后续恢复
  if (postData.images && postData.images.length > 0) {
    // 保存完整的图片URL到临时存储
    const fullImageUrls = postData.images.map(path => {
      if (path && typeof path === 'string' && !path.startsWith('http')) {
        // 确保使用正确的URL格式
        return `http://localhost:8080${path.startsWith('/') ? '' : '/'}${path}`;
      } else if (path && typeof path === 'string' && path.includes('/api/uploads')) {
        // 修复错误的URL格式
        return path.replace('/api/uploads', '/uploads');
      }
      return path;
    });
    console.log('保存完整图片URL到临时存储:', fullImageUrls);
    wx.setStorageSync('temp_images', fullImageUrls);
  }
  
  console.log('处理后的发布数据:', postData);
  
  return new Promise((resolve, reject) => {
    // 首先获取token
    const getTokenAndPublish = () => {
      wx.getStorage({
        key: 'token',
        success: (res) => {
          const token = res.data;
          if (!token) {
            console.error('获取到的token为空');
            resolve({
              code: 401,
              message: '请先登录',
              data: null
            });
            return;
          }
          
          // 发送请求
          sendPublishRequest(token);
        },
        fail: (err) => {
          console.error('获取token失败:', err);
          wx.redirectTo({
            url: '/pages/login/index'
          });
          resolve({
            code: 401,
            message: '请先登录',
            data: null
          });
        }
      });
    };
    
    // 发送帖子发布请求
    const sendPublishRequest = (token) => {
      console.log('开始发送帖子发布请求');
      wx.request({
        url: `${BASE_URL}/post/publish`, // 修复：去掉重复的/api前缀
        method: 'POST',
        header: {
          'Content-Type': 'application/json',
          'Authorization': token
        },
        data: postData,
        success: (res) => {
          console.log('发布帖子响应:', res);
          
          // 处理成功响应
          if (res.statusCode === 200 && res.data && res.data.code === 200) {
            console.log('帖子发布成功:', res.data.data);
            
            // 如果返回的帖子数据中没有图片，但我们有图片，添加上
            const postResult = res.data.data || {};
            if ((!postResult.images || postResult.images.length === 0) && 
                postData.images && postData.images.length > 0) {
              console.log('为返回的帖子数据添加图片:', postData.images);
              postResult.images = postData.images;
            }
            
            // 确保返回标准格式的结果对象
            resolve({
              code: 200,
              message: '发布成功',
              data: postResult
            });
          } 
          // 处理需要登录的情况
          else if (res.data && res.data.code === 401) {
            console.error('发布帖子需要登录:', res.data);
            wx.redirectTo({
              url: '/pages/login/index'
            });
            resolve({
              code: 401,
              message: res.data.message || '请先登录',
              data: null
            });
          } 
          // 处理其他服务器错误
          else {
            console.error('发布帖子服务器返回错误:', res.data);
            
            if (retryCount < 2) {
              console.log(`尝试重新发布帖子，第${retryCount + 1}次重试`);
              setTimeout(() => {
                publishPost(data, retryCount + 1)
                  .then(retryResult => resolve(retryResult))
                  .catch(retryError => reject(retryError));
              }, 1000);
            } else {
              resolve({
                code: res.data.code || 500,
                message: res.data.message || '发布失败',
                data: null
              });
            }
          }
        },
        fail: (err) => {
          console.error('发布帖子请求失败:', err);
          
          // 网络错误时尝试重试
          if (retryCount < 2) {
            console.log(`尝试重新发布帖子，第${retryCount + 1}次重试`);
            setTimeout(() => {
              publishPost(data, retryCount + 1)
                .then(retryResult => resolve(retryResult))
                .catch(retryError => reject(retryError));
            }, 1000);
          } else {
            // 返回标准错误格式
            resolve({
              code: 500,
              message: err.errMsg || '网络请求失败',
              data: null
            });
          }
        }
      });
    };
    
    // 开始执行
    getTokenAndPublish();
  });
}

// 获取帖子详情
function getPostDetail(postId) {
  return new Promise((resolve, reject) => {
    console.log('开始获取帖子详情，ID:', postId);
    wx.getStorage({
      key: 'token',
      success: (res) => {
        const token = res.data;
        console.log('使用Token获取帖子详情:', token);
        
        wx.request({
          url: `${BASE_URL}/post/${postId}`,
          method: 'GET',
          header: {
            'Authorization': token
          },
          success: (res) => {
            console.log('帖子详情响应:', res);
            
            if (res.statusCode !== 200) {
              console.error('HTTP错误:', res.statusCode);
              reject(new Error(`服务器返回错误: ${res.statusCode}`));
              return;
            }
            
            if (res.data.code === 200) {
              const postData = res.data.data;
              
              // 处理图片字段
              if (postData.images) {
                console.log('API - 原始图片数据:', postData.images, typeof postData.images);
                
                // 如果是字符串，尝试解析为JSON
                if (typeof postData.images === 'string') {
                  try {
                    postData.images = JSON.parse(postData.images);
                    console.log('API - JSON解析后的图片:', postData.images);
                  } catch (e) {
                    console.error('API - 解析图片JSON失败:', e);
                    // 如果解析失败，可能是单个URL
                    postData.images = [postData.images];
                  }
                }
                
                // 确保是数组格式
                if (!Array.isArray(postData.images)) {
                  postData.images = [postData.images].filter(Boolean);
                }
                
                // 处理嵌套数组的情况
                if (postData.images.length > 0 && Array.isArray(postData.images[0])) {
                  console.log('API - 检测到嵌套数组格式的图片:', postData.images);
                  postData.images = postData.images[0];
                }
                
                console.log('API - 处理后的图片数据:', postData.images);
              } else if (!postData.images) {
                // 如果后端返回null，尝试从缓存恢复
                const cachedPost = wx.getStorageSync(`post_${postId}`);
                if (cachedPost && cachedPost.images && cachedPost.images.length > 0) {
                  console.log('API - 从缓存恢复图片:', cachedPost.images);
                  postData.images = cachedPost.images;
                } else {
                  postData.images = [];
                }
              }
              
              console.log('处理后的帖子详情数据:', postData);
              resolve(postData);
            } else if (res.data.code === 401) {
              console.warn('未授权获取帖子详情');
              wx.redirectTo({
                url: '/pages/login/index'
              });
              reject(new Error('请先登录'));
            } else {
              console.error('获取帖子详情业务错误:', res.data.message);
              reject(new Error(res.data.message || '获取帖子详情失败'));
            }
          },
          fail: (err) => {
            console.error('获取帖子详情网络错误:', err);
            reject(err);
          }
        });
      },
      fail: () => {
        console.warn('获取Token失败，跳转登录页');
        wx.redirectTo({
          url: '/pages/login/index'
        });
        reject(new Error('请先登录'));
      }
    });
  });
}

// 删除帖子
function deletePost(postId) {
  return new Promise((resolve, reject) => {
    wx.getStorage({
      key: 'token',
      success: (res) => {
        wx.request({
          url: `${BASE_URL}/post/${postId}`,
          method: 'DELETE',
          header: {
            'Authorization': res.data
          },
          success: (res) => {
            if (res.data.code === 200) {
              resolve(res.data.data);
            } else if (res.data.code === 401) {
              wx.redirectTo({
                url: '/pages/login/index'
              });
            } else {
              reject(new Error(res.data.message));
            }
          },
          fail: reject
        });
      },
      fail: () => {
        wx.redirectTo({
          url: '/pages/login/index'
        });
      }
    });
  });
}

// 获取评论列表
function getCommentList(postId, pageNum = 1, pageSize = 10) {
  return new Promise((resolve, reject) => {
    console.log('开始获取评论列表，帖子ID:', postId);
    wx.getStorage({
      key: 'token',
      success: (res) => {
        const token = res.data;
        console.log('使用Token获取评论列表:', token);
        
        wx.request({
          url: `${BASE_URL}/comment/list/${postId}`,
          method: 'GET',
          header: {
            'Authorization': token
          },
          success: (res) => {
            console.log('评论列表响应:', res);
            
            if (res.statusCode !== 200) {
              console.error('HTTP错误:', res.statusCode);
              reject(new Error(`服务器返回错误: ${res.statusCode}`));
              return;
            }
            
            if (res.data.code === 200) {
              console.log('评论列表数据:', res.data.data);
              resolve(res.data.data);
            } else if (res.data.code === 401) {
              console.warn('未授权访问评论列表');
              wx.redirectTo({
                url: '/pages/login/index'
              });
              reject(new Error('请先登录'));
            } else {
              console.error('获取评论列表业务错误:', res.data.message);
              reject(new Error(res.data.message || '获取评论列表失败'));
            }
          },
          fail: (err) => {
            console.error('获取评论列表网络错误:', err);
            reject(err);
          }
        });
      },
      fail: () => {
        console.warn('获取Token失败，跳转登录页');
        wx.redirectTo({
          url: '/pages/login/index'
        });
        reject(new Error('请先登录'));
      }
    });
  });
}

// 发表评论
function publishComment(data) {
  return new Promise((resolve, reject) => {
    wx.getStorage({
      key: 'token',
      success: (res) => {
        wx.request({
          url: `${BASE_URL}/comment/publish`,
          method: 'POST',
          header: {
            'Authorization': res.data,
            'Content-Type': 'application/json'
          },
          data: data,
          success: (res) => {
            if (res.data.code === 200) {
              resolve(res.data.data);
            } else if (res.data.code === 401) {
              wx.redirectTo({
                url: '/pages/login/index'
              });
            } else {
              reject(new Error(res.data.message));
            }
          },
          fail: reject
        });
      },
      fail: () => {
        wx.redirectTo({
          url: '/pages/login/index'
        });
      }
    });
  });
}

// 删除评论
function deleteComment(commentId) {
  return new Promise((resolve, reject) => {
    wx.getStorage({
      key: 'token',
      success: (res) => {
        wx.request({
          url: `${BASE_URL}/comment/${commentId}`,
          method: 'DELETE',
          header: {
            'Authorization': res.data
          },
          success: (res) => {
            if (res.data.code === 200) {
              resolve(res.data.data);
            } else if (res.data.code === 401) {
              wx.redirectTo({
                url: '/pages/login/index'
              });
            } else {
              reject(new Error(res.data.message));
            }
          },
          fail: reject
        });
      },
      fail: () => {
        wx.redirectTo({
          url: '/pages/login/index'
        });
      }
    });
  });
}

// 点赞/取消点赞
function toggleLike(data) {
  return new Promise((resolve, reject) => {
    wx.getStorage({
      key: 'token',
      success: (res) => {
        wx.request({
          url: `${BASE_URL}/like/toggle`,
          method: 'POST',
          header: {
            'Authorization': res.data,
            'Content-Type': 'application/json'
          },
          data: data,
          success: (res) => {
            if (res.data.code === 200) {
              resolve(res.data.data);
            } else if (res.data.code === 401) {
              wx.redirectTo({
                url: '/pages/login/index'
              });
            } else {
              reject(new Error(res.data.message));
            }
          },
          fail: reject
        });
      },
      fail: () => {
        wx.redirectTo({
          url: '/pages/login/index'
        });
      }
    });
  });
}

/**
 * 上传图片
 * @param {string} filePath 文件路径
 * @returns {Promise<string>} 上传后的图片URL
 */
function uploadImage(filePath) {
  console.log('API - 开始上传图片', filePath);
  console.log('API - 使用BASE_URL:', BASE_URL);
  
  return new Promise((resolve, reject) => {
    if (!filePath) {
      console.error('API - 无效的文件路径');
      reject(new Error('无效的文件路径'));
      return;
    }
    
    // 获取 token
    wx.getStorage({
      key: 'token',
      success: (res) => {
        wx.uploadFile({
          // 修复URL路径，移除重复的/api前缀
          url: `${BASE_URL}/file/upload`,
          filePath,
          name: 'file',
          header: {
            'Authorization': res.data
          },
          success: (res) => {
            console.log('API - 图片上传响应:', res);
            try {
              const data = JSON.parse(res.data);
              console.log('API - 解析后的上传响应:', data);
              
              if (data.code === 200) {
                // 获取图片路径
                let url = data.data.url || data.data;
                console.log('API - 原始返回的图片URL:', url);
                
                // 确保URL是完整的，可以直接访问
                if (url && typeof url === 'string') {
                  // 如果不是完整URL，添加域名前缀
                  if (!url.startsWith('http')) {
                    // 确保路径以/开头
                    if (!url.startsWith('/')) {
                      url = '/' + url;
                    }
                    // 添加域名前缀
                    url = BASE_URL.replace('/api', '') + url;
                  }
                  
                  console.log('API - 处理后的完整图片URL:', url);
                  resolve(url);
                } else {
                  console.error('API - 无效的图片URL:', url);
                  reject(new Error('无效的图片URL'));
                }
              } else if (data.code === 401) {
                console.warn('API - 未授权上传图片');
                wx.redirectTo({
                  url: '/pages/login/index'
                });
                reject(new Error('请先登录'));
              } else {
                console.error('API - 上传失败:', data.message);
                reject(new Error(data.message || '上传失败'));
              }
            } catch (e) {
              console.error('API - 解析上传响应失败:', e, res.data);
              
              // 尝试直接使用响应数据
              if (res.statusCode === 200 && res.data) {
                try {
                  // 尝试提取路径
                  const match = res.data.match(/\/uploads\/[^"']+/);
                  if (match) {
                    const url = match[0];
                    console.log('API - 从响应中提取的图片路径:', url);
                    resolve(url);
                    return;
                  }
                } catch (ex) {
                  console.error('API - 提取图片路径失败:', ex);
                }
              }
              
              reject(new Error('解析上传响应失败'));
            }
          },
          fail: (err) => {
            console.error('API - 上传请求失败:', err);
            reject(err);
          }
        });
      },
      fail: () => {
        console.warn('API - 获取Token失败，跳转登录页');
        wx.redirectTo({
          url: '/pages/login/index'
        });
        reject(new Error('请先登录'));
      }
    });
  });
}

/**
 * 获取留言列表
 * @param {number} page 页码
 * @param {number} pageSize 每页数量
 * @returns {Promise} 留言列表
 */
function getMessageList(page = 1, pageSize = 10) {
  console.log('API - 获取留言列表:', { page, pageSize });

  return new Promise((resolve, reject) => {
    const token = wx.getStorageSync('token');
    if (!token) {
      console.error('未登录状态下请求留言列表');
      reject(new Error('请先登录'));
      return;
    }

    wx.request({
      url: `${BASE_URL}/message/list`,
      method: 'GET',
      data: { page, pageSize },
      header: {
        'Authorization': token
      },
      success: (res) => {
        console.log('留言列表响应:', res);
        if (res.statusCode === 200 && res.data.code === 200) {
          resolve(res.data.data);
        } else if (res.statusCode === 401 || (res.data && res.data.code === 401)) {
          console.warn('获取留言列表未授权');
          wx.navigateTo({
            url: '/pages/login/index'
          });
          reject(new Error('请先登录'));
        } else {
          console.error('获取留言列表失败:', res.data);
          reject(new Error(res.data.message || '获取留言列表失败'));
        }
      },
      fail: (err) => {
        console.error('获取留言列表请求失败:', err);
        reject(err);
      }
    });
  });
}

/**
 * 发布留言
 * @param {Object} messageData 留言数据
 * @returns {Promise} 发布结果
 */
function publishMessage(messageData) {
  console.log('API - 发布留言:', messageData);

  return new Promise((resolve, reject) => {
    const token = wx.getStorageSync('token');
    if (!token) {
      console.error('未登录状态下发布留言');
      reject(new Error('请先登录'));
      return;
    }

    wx.request({
      url: `${BASE_URL}/message/publish`,
      method: 'POST',
      data: messageData,
      header: {
        'Authorization': token,
        'Content-Type': 'application/json'
      },
      success: (res) => {
        console.log('发布留言响应:', res);
        if (res.statusCode === 200 && res.data.code === 200) {
          resolve(res.data.data);
        } else if (res.statusCode === 401 || (res.data && res.data.code === 401)) {
          console.warn('发布留言未授权');
          wx.navigateTo({
            url: '/pages/login/index'
          });
          reject(new Error('请先登录'));
        } else {
          console.error('发布留言失败:', res.data);
          reject(new Error(res.data.message || '发布留言失败'));
        }
      },
      fail: (err) => {
        console.error('发布留言请求失败:', err);
        reject(err);
      }
    });
  });
}

// 测试帖子列表API，使用特定的测试Token
function testPostList() {
  return new Promise((resolve, reject) => {
    // 获取存储的token
    const token = wx.getStorageSync('token');
    
    console.log('测试API使用Token:', token);
    
    wx.request({
      url: `${BASE_URL}/post/list`,
      method: 'GET',
      header: {
        'Authorization': token || 'test-token',
        'Content-Type': 'application/json'
      },
      data: {
        pageNum: 1,
        pageSize: 10
      },
      success: (res) => {
        console.log('测试帖子列表返回:', res);
        
        if (res.statusCode === 401) {
          // 401未授权，需要登录
          console.log('API需要授权访问，请先登录');
          return resolve({
            code: 401,
            message: '请先登录'
          });
        }
        
        if (res.statusCode !== 200) {
          console.error(`HTTP错误: ${res.statusCode}`);
          return reject(new Error(`HTTP错误: ${res.statusCode}`));
        }
        
        // 检查后端的响应结构
        if (res.data && res.data.code === 200) {
          console.log('API测试成功，检查数据结构');
          
          if (res.data.data && res.data.data.records) {
            const posts = res.data.data.records;
            console.log('接收到帖子数量:', posts.length);
            if (posts.length > 0) {
              console.log('数据结构示例:', posts[0]);
              console.log('帖子包含的字段:', Object.keys(posts[0]));
            }
          }
          
          // 返回整个响应对象供调试
          resolve(res);
        } else {
          console.error('API错误:', res.data);
          reject(new Error('API返回错误: ' + (res.data ? res.data.message : '未知错误')));
        }
      },
      fail: (err) => {
        console.error('网络请求失败:', err);
        reject(err);
      }
    });
  });
}

// 模考大赛相关API
const competitionApi = {
  // 获取所有模考大赛
  getAllCompetitions: (userId) => {
    return new Promise((resolve, reject) => {
      const token = wx.getStorageSync('token');
      if (!token) {
        console.error('未登录状态下请求模考大赛列表');
        wx.navigateTo({
          url: '/pages/login/index'
        });
        reject(new Error('请先登录'));
        return;
      }

      console.log('获取模考大赛列表，使用token:', token);

      wx.request({
        url: `${BASE_URL}/competitions`,
        method: 'GET',
        header: {
          'Authorization': token,
          'Content-Type': 'application/json'
        },
        data: { userId },
        success(res) {
          console.log('获取模考大赛响应:', res);
          
          if (res.statusCode === 401) {
            console.error('token已过期或无效');
            // 清除无效token
            wx.removeStorageSync('token');
            wx.removeStorageSync('userInfo');
            // 跳转到登录页
            wx.navigateTo({
              url: '/pages/login/index'
            });
            reject(new Error('登录已过期，请重新登录'));
            return;
          }
          
          if (res.statusCode !== 200 || !res.data || res.data.code !== 200) {
            const errorMsg = res.data ? res.data.message || '获取模考大赛失败' : '服务器响应异常';
            console.error('获取模考大赛失败:', errorMsg);
            reject(new Error(errorMsg));
            return;
          }
          
          resolve(res.data.data || []);
        },
        fail(err) {
          console.error('网络请求失败:', err);
          reject(new Error('网络请求失败: ' + err.errMsg));
        }
      });
    });
  },
  
  // 报名模考大赛
  register: (userId, username, competitionId, positionType) => {
    return new Promise((resolve, reject) => {
      const token = wx.getStorageSync('token');
      if (!token) {
        console.error('未登录状态下请求报名模考大赛');
        wx.navigateTo({
          url: '/pages/login/index'
        });
        reject(new Error('请先登录'));
        return;
      }

      console.log('报名模考大赛，使用token:', token);
      console.log('报名参数:', { userId, username, competitionId, positionType });

      // 构建URL查询参数
      const url = `${BASE_URL}/competitions/register?userId=${userId}&username=${encodeURIComponent(username)}&competitionId=${competitionId}&positionType=${encodeURIComponent(positionType)}`;
      
      console.log('报名请求URL:', url);

      wx.request({
        url: url,
        method: 'POST',
        header: {
          'Authorization': token
        },
        success(res) {
          console.log('报名模考大赛响应:', res);
          
          if (res.statusCode === 401) {
            console.error('token已过期或无效');
            // 清除无效token
            wx.removeStorageSync('token');
            wx.removeStorageSync('userInfo');
            // 跳转到登录页
            wx.navigateTo({
              url: '/pages/login/index'
            });
            reject(new Error('登录已过期，请重新登录'));
            return;
          }
          
          if (res.statusCode !== 200 || !res.data || res.data.code !== 200) {
            const errorMsg = res.data ? res.data.message || '报名模考大赛失败' : '服务器响应异常';
            console.error('报名模考大赛失败:', errorMsg);
            reject(new Error(errorMsg));
            return;
          }
          
          resolve(res.data.data);
        },
        fail(err) {
          console.error('网络请求失败:', err);
          reject(new Error('网络请求失败: ' + err.errMsg));
        }
      });
    });
  },
  
  // 设置提醒状态
  setRemindStatus: (userId, competitionId, isReminded) => {
    return new Promise((resolve, reject) => {
      const token = wx.getStorageSync('token');
      if (!token) {
        console.error('未登录状态下请求设置提醒状态');
        wx.navigateTo({
          url: '/pages/login/index'
        });
        reject(new Error('请先登录'));
        return;
      }

      console.log('设置提醒状态，使用token:', token);
      console.log('提醒参数:', { userId, competitionId, isReminded });

      // 构建URL查询参数
      const url = `${BASE_URL}/competitions/remind?userId=${userId}&competitionId=${competitionId}&isReminded=${isReminded}`;
      
      console.log('提醒请求URL:', url);

      wx.request({
        url: url,
        method: 'POST',
        header: {
          'Authorization': token
        },
        success(res) {
          console.log('设置提醒状态响应:', res);
          
          if (res.statusCode === 401) {
            console.error('token已过期或无效');
            // 清除无效token
            wx.removeStorageSync('token');
            wx.removeStorageSync('userInfo');
            // 跳转到登录页
            wx.navigateTo({
              url: '/pages/login/index'
            });
            reject(new Error('登录已过期，请重新登录'));
            return;
          }
          
          if (res.statusCode !== 200 || !res.data || res.data.code !== 200) {
            const errorMsg = res.data ? res.data.message || '设置提醒状态失败' : '服务器响应异常';
            console.error('设置提醒状态失败:', errorMsg);
            reject(new Error(errorMsg));
            return;
          }
          
          resolve(res.data.data);
        },
        fail(err) {
          console.error('网络请求失败:', err);
          reject(new Error('网络请求失败: ' + err.errMsg));
        }
      });
    });
  },
  
  // 取消报名
  cancelRegistration: (userId, competitionId) => {
    return new Promise((resolve, reject) => {
      const token = wx.getStorageSync('token');
      if (!token) {
        console.error('未登录状态下请求取消报名');
        wx.navigateTo({
          url: '/pages/login/index'
        });
        reject(new Error('请先登录'));
        return;
      }

      console.log('取消报名，使用token:', token);
      console.log('取消报名参数:', { userId, competitionId });

      // 构建URL查询参数
      const url = `${BASE_URL}/competitions/cancel?userId=${userId}&competitionId=${competitionId}`;
      
      console.log('取消报名请求URL:', url);

      wx.request({
        url: url,
        method: 'POST',
        header: {
          'Authorization': token
        },
        success(res) {
          console.log('取消报名响应:', res);
          
          if (res.statusCode === 401) {
            console.error('token已过期或无效');
            // 清除无效token
            wx.removeStorageSync('token');
            wx.removeStorageSync('userInfo');
            // 跳转到登录页
            wx.navigateTo({
              url: '/pages/login/index'
            });
            reject(new Error('登录已过期，请重新登录'));
            return;
          }
          
          if (res.statusCode !== 200 || !res.data || res.data.code !== 200) {
            const errorMsg = res.data ? res.data.message || '取消报名失败' : '服务器响应异常';
            console.error('取消报名失败:', errorMsg);
            reject(new Error(errorMsg));
            return;
          }
          
          resolve(res.data.data);
        },
        fail(err) {
          console.error('网络请求失败:', err);
          reject(new Error('网络请求失败: ' + err.errMsg));
        }
      });
    });
  }
};

// 获取试题列表
const getQuestions = (competitionId) => {
  return new Promise((resolve, reject) => {
    const token = wx.getStorageSync('token');
    if (!token) {
      console.error('未登录状态下请求试题列表');
      wx.navigateTo({
        url: '/pages/login/index'
      });
      reject(new Error('请先登录'));
      return;
    }

    console.log('获取试题列表，竞赛ID:', competitionId);

    wx.request({
      url: `${BASE_URL}/questions/${competitionId}`,
      method: 'GET',
      header: {
        'Authorization': token
      },
      success(res) {
        console.log('获取试题列表响应:', res);
        
        if (res.statusCode === 401) {
          console.error('token已过期或无效');
          wx.removeStorageSync('token');
          wx.removeStorageSync('userInfo');
          wx.navigateTo({
            url: '/pages/login/index'
          });
          reject(new Error('登录已过期，请重新登录'));
          return;
        }
        
        if (res.statusCode !== 200 || !res.data || res.data.code !== 200) {
          const errorMsg = res.data ? res.data.message || '获取试题列表失败' : '服务器响应异常';
          console.error('获取试题列表失败:', errorMsg);
          reject(new Error(errorMsg));
          return;
        }
        
        resolve(res.data.data);
      },
      fail(err) {
        console.error('网络请求失败:', err);
        reject(new Error('网络请求失败: ' + err.errMsg));
      }
    });
  });
};

// 提交答案
const submitAnswers = (userId, competitionId, answers, duration) => {
  return new Promise((resolve, reject) => {
    const token = wx.getStorageSync('token');
    if (!token) {
      console.error('未登录状态下提交答案');
      wx.navigateTo({
        url: '/pages/login/index'
      });
      reject(new Error('请先登录'));
      return;
    }

    console.log('提交答案，参数:', { userId, competitionId, answers, duration });

    wx.request({
      url: `${BASE_URL}/questions/submit`,
      method: 'POST',
      header: {
        'Authorization': token,
        'Content-Type': 'application/json'
      },
      data: {
        userId,
        competitionId,
        answers,
        duration
      },
      success(res) {
        console.log('提交答案响应:', res);
        
        if (res.statusCode === 401) {
          console.error('token已过期或无效');
          wx.removeStorageSync('token');
          wx.removeStorageSync('userInfo');
          wx.navigateTo({
            url: '/pages/login/index'
          });
          reject(new Error('登录已过期，请重新登录'));
          return;
        }
        
        if (res.statusCode !== 200 || !res.data || res.data.code !== 200) {
          const errorMsg = res.data ? res.data.message || '提交答案失败' : '服务器响应异常';
          console.error('提交答案失败:', errorMsg);
          reject(new Error(errorMsg));
          return;
        }
        
        resolve(res.data.data);
      },
      fail(err) {
        console.error('网络请求失败:', err);
        reject(new Error('网络请求失败: ' + err.errMsg));
      }
    });
  });
};

// 获取考试结果
const getExamResult = (userId, competitionId) => {
  return new Promise((resolve, reject) => {
    const token = wx.getStorageSync('token');
    if (!token) {
      console.error('未登录状态下获取考试结果');
      wx.navigateTo({
        url: '/pages/login/index'
      });
      reject(new Error('请先登录'));
      return;
    }

    console.log('获取考试结果，参数:', { userId, competitionId });

    wx.request({
      url: `${BASE_URL}/questions/result`,
      method: 'GET',
      header: {
        'Authorization': token
      },
      data: {
        userId,
        competitionId
      },
      success(res) {
        console.log('获取考试结果响应:', res);
        
        if (res.statusCode === 401) {
          console.error('token已过期或无效');
          wx.removeStorageSync('token');
          wx.removeStorageSync('userInfo');
          wx.navigateTo({
            url: '/pages/login/index'
          });
          reject(new Error('登录已过期，请重新登录'));
          return;
        }
        
        if (res.statusCode !== 200 || !res.data || res.data.code !== 200) {
          const errorMsg = res.data ? res.data.message || '获取考试结果失败' : '服务器响应异常';
          console.error('获取考试结果失败:', errorMsg);
          reject(new Error(errorMsg));
          return;
        }
        
        resolve(res.data.data);
      },
      fail(err) {
        console.error('网络请求失败:', err);
        reject(new Error('网络请求失败: ' + err.errMsg));
      }
    });
  });
};

// 导出API函数
module.exports = {
  // 保留直接导出的函数
  getPostList,
  getPostDetail,
  publishPost,
  deletePost,
  getCommentList,
  publishComment,
  deleteComment,
  toggleLike,
  uploadImage,
  getMessageList,
  publishMessage,
  testPostList,
  getQuestions,
  submitAnswers,
  getExamResult,
  
  // 恢复嵌套对象导出，兼容旧代码
  postApi: {
    getPostList,
    publishPost,
    getPostDetail,
    deletePost,
    getCommentList,  // 将评论列表函数也添加到postApi中，兼容现有代码
    publishComment,  // 确保评论发布函数在postApi中可用
    addComment: publishComment, // 添加别名，兼容现有代码
    toggleLike
  },
  commentApi: {
    getCommentList,
    publishComment,
    deleteComment
  },
  likeApi: {
    toggleLike
  },
  fileApi: {
    uploadImage
  },
  messageApi: {
    getMessageList,
    publishMessage
  },
  competitionApi,  // 添加竞赛API
  questionApi: {
    getQuestions,
    submitAnswers,
    getExamResult
  }
};